Your job flow:
1. Greet the customer warmly
2. Call get_menu() once (silently) to know what's available
3. Collect: pizza type, size, crust (default: thin), extras, removals
4. Call calc_price() once you have all details
5. Call validate_order() — read VALID or INVALID response
6. If VALID → present summary + ask for confirmation
7. If INVALID → fix issues, recalculate, re-validate
8. On confirmation → call submit_order()
9. Reply with order ID + ETA, then: TERMINATE

python -m venv .venv
source .venv/bin/activate
pip install pyautogen python-dotenv

import os
from dotenv import load_dotenv
load_dotenv()
LLM_CONFIG = {
    "config_list": [{"model": "gpt-4o", "api_key": os.getenv("OPENAI_API_KEY")}],
    "temperature": 0.2, "cache_seed": None,
}

PIZZAS = {
    "margherita":  {"base_price": {"small":10,"medium":14,"large":18,"xl":22},
                    "default_toppings": ["mozzarella","tomato_sauce","basil"]},
    "pepperoni":   {"base_price": {"small":12,"medium":16,"large":20,"xl":24},
                    "default_toppings": ["mozzarella","tomato_sauce","pepperoni"]},
    "bbq_chicken": { ... },
    "veggie":      { ... },
}
EXTRA_TOPPINGS = {"extra_cheese":2.0, "mushroom":1.5, "bacon":2.5, ...}
CRUSTS = ["thin", "thick", "stuffed", "gluten_free"]
CRUST_UPCHARGE = {"stuffed": 3.0, "gluten_free": 2.0}

def get_menu() -> str:
    """Return full menu as JSON string."""
    return json.dumps({"pizzas": ..., "extra_toppings": ..., "crusts": ...})

def calc_price(pizza_type: str, size: str, crust: str="thin", extra_toppings: list=None) -> str:
    """Calculate total price. Returns JSON with total + breakdown."""
    total = PIZZAS[pizza_type]["base_price"][size] + CRUST_UPCHARGE.get(crust, 0)
    for t in (extra_toppings or []): total += EXTRA_TOPPINGS[t]
    return json.dumps({"total": round(total, 2), "breakdown": {...}})

def submit_order(pizza_type, size, crust, extra_toppings, remove_toppings, total_price, customer_name="Guest") -> str:
    """Submit order to kitchen. Returns order_id + ETA."""
    order_id = f"ORD-{random.randint(10000,99999)}"
    # In production: write to DB, call kitchen API, send SMS...
    return json.dumps({"order_id": order_id, "eta": eta, "message": "Confirmed!"})

def register_tools(order_agent, validator_agent, user_proxy):

    @user_proxy.register_for_execution()
    @order_agent.register_for_llm(description="Fetch the full pizza menu")
    def _get_menu() -> str: return get_menu()

    @user_proxy.register_for_execution()
    @order_agent.register_for_llm(description="Calculate total price")
    def _calc_price(pizza_type: str, size: str, crust: str="thin", extra_toppings: list=None) -> str:
        return calc_price(pizza_type, size, crust, extra_toppings)

    @user_proxy.register_for_execution()
    @order_agent.register_for_llm(description="Validate order before confirming with customer")
    def _validate_order(pizza_type: str, size: str, crust: str,
        extra_toppings: list, remove_toppings: list, price: float) -> str:
        # Spins up a one-shot ValidatorAgent chat, returns "VALID" or "INVALID: ..."
        order_str = json.dumps({"pizza_type": pizza_type, "size": size, ...})
        vproxy = autogen.UserProxyAgent(name="vp", human_input_mode="NEVER",
            is_termination_msg=lambda x: True, code_execution_config=False)
        vproxy.initiate_chat(validator_agent,
            message=f"Validate:\n{order_str}", max_turns=1, silent=True)
        history = validator_agent.chat_messages.get(vproxy, [])
        for m in reversed(history):
            if m["role"] == "assistant": return m["content"]

    @user_proxy.register_for_execution()
    @order_agent.register_for_llm(description="Submit confirmed order. Call ONLY after customer says yes.")
    def _submit_order(pizza_type, size, crust, extra_toppings, remove_toppings, total_price, customer_name="Guest") -> str:
        return submit_order(pizza_type, size, crust, extra_toppings, remove_toppings, total_price, customer_name)

You are a strict pizza order validator for PizzaLab.

Check ALL of the following:
1. pizza_type is one of: margherita, pepperoni, bbq_chicken, veggie
2. size is one of: small, medium, large, xl
3. crust is one of: thin, thick, stuffed, gluten_free
4. All extra_toppings are on the extras menu
5. Price is plausible for size + extras

Respond with EXACTLY one of:
- "VALID"
- "INVALID: [issue 1]; [issue 2]"

No extra text. Be terse.

# KEY LESSON: human_input_mode="ALWAYS" prompts on EVERY turn
# including tool-call turns. Fix: use NEVER + a smart reply function.

def smart_human_reply(recipient, messages, sender, config):
    last = messages[-1] if messages else {}
    role = last.get("role", "")

    if role == "tool":          # tool result turn — pass through
        return False, None
    if last.get("tool_calls"):  # tool call turn — pass through
        return False, None       # ← CRITICAL: prevents 400 BadRequestError

    # Genuine conversational turn — ask the human
    human_input = input("You: ").strip()
    if human_input.lower() == "exit": return True, "exit"
    return True, human_input

user_proxy = autogen.UserProxyAgent(name="customer", human_input_mode="NEVER", ...)
user_proxy.register_reply(trigger=[autogen.AssistantAgent, None],
    reply_func=smart_human_reply, position=0)

# Automated test (scripted replies, no typing needed)
python main.py

# Interactive mode (you type each customer reply)
INTERACTIVE=1 python main.py